#!/usr/bin/env node

/**
 * 增强版启动脚本
 * 包含数据库连接测试、配置验证和自动修复功能
 */

import { execSync } from 'child_process';
import fs from 'fs';
import path from 'path';

// 应用启动器类
class EnhancedApplicationStarter {
    constructor() {
        this.config = this.loadConfig();
        this.databaseStatus = {
            postgresql: false,
            redis: false,
            mongodb: false,
            sqlite: false
        };
    }

    // 加载配置
    loadConfig() {
        const envPath = path.join(process.cwd(), '.env');
        if (!fs.existsSync(envPath)) {
            console.log('❌ 找不到.env文件，使用默认配置');
            return {};
        }

        const envContent = fs.readFileSync(envPath, 'utf8');
        const config = {};

        envContent.split('\n').forEach(line => {
            if (line.trim() && !line.startsWith('#')) {
                const [key, value] = line.split('=');
                if (key && value) {
                    config[key.trim()] = value.trim();
                }
            }
        });

        console.log('✅ 环境配置加载完成');
        return config;
    }

    // 启动数据库服务
    async startDatabases() {
        console.log('🚀 启动数据库服务...');

        try {
            // 执行数据库启动脚本
            execSync('chmod +x scripts/start-databases.sh', { stdio: 'inherit' });
            execSync('./scripts/start-databases.sh', { stdio: 'inherit' });
            
            console.log('✅ 数据库服务启动完成');
        } catch (error) {
            console.log('⚠️ 数据库启动脚本执行失败:', error.message);
        }

        // 测试数据库连接
        await this.testDatabaseConnections();
    }

    // 测试数据库连接
    async testDatabaseConnections() {
        console.log('\n🔗 测试数据库连接...');

        try {
            // 执行数据库连接测试脚本
            execSync('node scripts/test-database-connection.js', { stdio: 'inherit' });
        } catch (error) {
            console.log('❌ 数据库连接测试失败:', error.message);
            console.log('💡 应用将在降级模式下运行');
        }
    }

    // 初始化SQLite备用数据库
    async initSQLiteDatabase() {
        console.log('💾 初始化SQLite备用数据库...');

        try {
            if (fs.existsSync('scripts/init-sqlite.js')) {
                execSync('node scripts/init-sqlite.js', { stdio: 'inherit' });
                this.databaseStatus.sqlite = fs.existsSync('data/bike_wholesale.db');
                
                if (this.databaseStatus.sqlite) {
                    console.log('✅ SQLite备用数据库初始化完成');
                } else {
                    console.log('❌ SQLite备用数据库初始化失败');
                }
            } else {
                console.log('⚠️ SQLite初始化脚本不存在');
            }
        } catch (error) {
            console.log('❌ SQLite初始化失败:', error.message);
        }
    }

    // 检查数据库状态
    async checkDatabaseStatus() {
        console.log('\n📊 检查数据库状态...');

        const statusReport = [];

        // 检查PostgreSQL
        try {
            execSync('pgrep -x postgres > /dev/null', { stdio: 'pipe' });
            statusReport.push('✅ PostgreSQL: 运行中');
            this.databaseStatus.postgresql = true;
        } catch {
            statusReport.push('❌ PostgreSQL: 未运行');
        }

        // 检查Redis
        try {
            execSync('pgrep -x redis-server > /dev/null', { stdio: 'pipe' });
            statusReport.push('✅ Redis: 运行中');
            this.databaseStatus.redis = true;
        } catch {
            statusReport.push('❌ Redis: 未运行');
        }

        // 检查MongoDB
        try {
            execSync('pgrep -x mongod > /dev/null', { stdio: 'pipe' });
            statusReport.push('✅ MongoDB: 运行中');
            this.databaseStatus.mongodb = true;
        } catch {
            statusReport.push('❌ MongoDB: 未运行');
        }

        // 检查SQLite
        if (fs.existsSync('data/bike_wholesale.db')) {
            statusReport.push('✅ SQLite: 备用数据库可用');
            this.databaseStatus.sqlite = true;
        } else {
            statusReport.push('❌ SQLite: 备用数据库不可用');
        }

        console.log(statusReport.join('\n'));

        // 统计可用数据库
        const availableDatabases = Object.values(this.databaseStatus).filter(status => status).length;
        console.log(`\n📈 可用数据库数量: ${availableDatabases}/4`);

        if (availableDatabases === 0) {
            console.log('⚠️ 警告：没有可用的数据库服务');
            console.log('💡 应用将使用内存存储（功能受限）');
        } else if (availableDatabases >= 2) {
            console.log('✅ 数据库配置良好，应用可以正常运行');
        }
    }

    // 启动应用服务
    async startApplicationServices() {
        console.log('\n🚀 启动应用服务...');

        // 检查PM2是否可用
        try {
            execSync('command -v pm2 > /dev/null', { stdio: 'pipe' });
            
            if (fs.existsSync('ecosystem.config.js')) {
                console.log('📦 使用PM2启动应用服务...');
                execSync('pm2 start ecosystem.config.js --env production', { stdio: 'inherit' });
                execSync('pm2 save', { stdio: 'inherit' });
                console.log('✅ PM2服务启动完成');
            } else {
                console.log('⚠️ PM2配置文件不存在，使用普通启动方式');
                this.startServicesManually();
            }
        } catch {
            console.log('⚠️ PM2不可用，使用普通启动方式');
            this.startServicesManually();
        }
    }

    // 手动启动服务
    startServicesManually() {
        console.log('🔧 手动启动应用服务...');

        // 启动后端服务
        if (fs.existsSync('backend/src/server-unified.js')) {
            console.log('🖥️ 启动后端服务...');
            try {
                const backendProcess = execSync('node backend/src/server-unified.js', { 
                    stdio: 'pipe',
                    detached: true 
                });
                console.log('✅ 后端服务启动成功');
            } catch (error) {
                console.log('❌ 后端服务启动失败:', error.message);
            }
        }

        // 启动前端服务
        if (fs.existsSync('frontend/server.js')) {
            console.log('🌐 启动前端服务...');
            try {
                const frontendProcess = execSync('node frontend/server.js', { 
                    stdio: 'pipe',
                    detached: true 
                });
                console.log('✅ 前端服务启动成功');
            } catch (error) {
                console.log('❌ 前端服务启动失败:', error.message);
            }
        }

        // 启动用户端服务
        if (fs.existsSync('user-client/server.js')) {
            console.log('👤 启动用户端服务...');
            try {
                const userClientProcess = execSync('node user-client/server.js', { 
                    stdio: 'pipe',
                    detached: true 
                });
                console.log('✅ 用户端服务启动成功');
            } catch (error) {
                console.log('❌ 用户端服务启动失败:', error.message);
            }
        }
    }

    // 显示启动信息
    showStartupInfo() {
        console.log('\n🎉 应用启动完成！');
        console.log('==================');
        console.log('📊 服务状态:');
        console.log('   后端服务: http://localhost:' + (this.config.BACKEND_PORT || '3000'));
        console.log('   前端服务: http://localhost:' + (this.config.FRONTEND_PORT || '8080'));
        console.log('   用户端服务: http://localhost:' + (this.config.USER_CLIENT_PORT || '3001'));
        console.log('');
        console.log('🔑 数据库账户信息:');
        console.log('   PostgreSQL:');
        console.log('     用户名: ' + (this.config.DB_USER || 'bike_admin'));
        console.log('     密码: ' + (this.config.DB_PASSWORD || 'BikeSecure123!@#'));
        console.log('     数据库: ' + (this.config.DB_NAME || 'bike_wholesale'));
        console.log('');
        console.log('   Redis:');
        console.log('     密码: ' + (this.config.REDIS_PASSWORD || 'RedisSecure456!@#'));
        console.log('');
        console.log('   MongoDB:');
        console.log('     连接字符串: ' + (this.config.MONGODB_URI || 'mongodb://bike_admin:MongoSecure789!@#@localhost:27017/bike_community'));
        console.log('==================');
        console.log('💡 提示: 请确保数据库服务已启动，应用才能正常运行');
    }

    // 主启动方法
    async start() {
        console.log('🚀 增强版应用启动器启动...\n');

        try {
            // 1. 启动数据库服务
            await this.startDatabases();

            // 2. 初始化SQLite备用数据库
            await this.initSQLiteDatabase();

            // 3. 检查数据库状态
            await this.checkDatabaseStatus();

            // 4. 启动应用服务
            await this.startApplicationServices();

            // 5. 显示启动信息
            this.showStartupInfo();

        } catch (error) {
            console.error('❌ 启动过程中发生错误:', error);
            process.exit(1);
        }
    }
}

// 启动应用
const starter = new EnhancedApplicationStarter();
starter.start().catch(error => {
    console.error('启动失败:', error);
    process.exit(1);
});